A grammar of graphics

The gg in ggplot stands for grammar of graphics, a particular approach to describing plots of data. You can read about it in more detail here, but the core idea is to describe all different kinds of plots in terms of a few basic components:

• data
• aesthetic mappings (or just aesthetics for short); a mapping of variables from the data onto dimensions of the plot, such as:
  • x dimension
  • y dimension
  • color
  • size
• geometric objects (or geoms for short); the shapes used to represent the data, such as:
  • points
  • lines
  • bars
  • or more complex shapes like error bars, boxplots, etc.

There are various other plot components implemented in ggplot, but we won’t always need to use all of them. These three are the important ones.

One of the advantages of this system is that we do not need a separate R command for every kind of plot that we want to create. Instead, we can build almost any plot we want out of a limited set of components. So there are no functions called, for example, scatterplot() or barchart() in ggplot. Instead, everything begins with just one function, ggplot(), which is used to specify the first two ingredients of the plot: the data and the aesthetic mappings.

The first input to ggplot() is the data frame containing the data we want to plot. The second input is itself a function, the aes() function. aes is short for aesthetic, and this function organizes the aesthetic mappings. Inside the aes() function, we assign variables from the data set to dimensions of the plot. We do this using the same = that we use for assignment in general.

So to display the babies’ birth weights along the y dimension and the mothers’ weights along the x dimension:

ggplot(bw, aes(y=Birth_weight, x=Weight))

In this first extremely minimal example, we didn’t yet add the third component mentioned above: a geometric object. So the plot does not yet show the data in any form. But notice that ggplot already does some useful automatic jobs. It has created the x and y scales with the necessary range, labeled them with the names of the variables that we mapped to them, and added gridlines to the plot background.

Now we will do it again with points as our geom, to produce a plot that actually shows the data. Geoms are added on to the core plot definition using +. Each geom has its own function, and these functions all begin with geom_. The function that we want for this example is called geom_point(). Because we have already defined the organization of the plot with aes(), geom_point() doesn’t need any input telling it what to plot or where.

ggplot(bw, aes(y=Birth_weight, x=Weight)) + geom_point()

If we use any other dimensions when defining the plot, such as color, size, or shape, any geom that is able to represent that dimension will take this into account. For example, points will be shown in different colors if a variable is mapped to the color dimension. A legend for the colors is added automatically.

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker)) + geom_point()

Adding to plots

We will often want to have a few different versions of our plot, for example a basic version showing the individual observations in the data, perhaps a version showing just mean values, a version that splits the data into two subgroups, and so on. It would be a bit tedious to have to repeat the basic underlying plot definition for each version, especially once our plot becomes quite complex. We should avoid this unnecessary repetition. The first step in doing so is to store the most basic form of our plot, so that we can use it repeatedly. We can store a plot by assigning it into a variable using =, just as we do for storing other types of information.

fig1 = ggplot(bw, aes(y=Birth_weight, x=Weight)) + geom_point()

Now the plot is stored and we can re-use it under this name. One thing we can do with a stored plot is display it again. This is done with the same print() function used for printing out the contents of variables.

print(fig1)

We can add new components to stored plots with +, and assign the result into a new variable in order to have a different version of the plot. For example, we can add a new aesthetic mapping with aes().

fig2 = fig1 + aes(color=Smoker)
print(fig2)

We can change an existing aesthetic mapping in the same way.

fig2 = fig1 + aes(x=Age)
print(fig2)

As well as new mappings, we can add new geoms to an existing plot. For example, a common accompaniment to geom_point() is a trend line showing a smooth relationship between the x and y variables. We can add this with geom_smooth().

fig2 = fig1 + geom_smooth()
print(fig2)

## `geom_smooth()` using method = 'loess' and formula 'y ~ x'

Notice that we also got a short message printed out when we ran geom_smooth(). This is not an error message but simply a warning. Some functions when we run them will print out a reminder of what the function is doing, so that we can check that it is really what we wanted. This occurs most often in cases where the function’s default behavior might not be what some users typically want.

The content of the warning message tells us something about a ‘method’ called ‘loess’, which geom_smooth() has used. loess stands for locally etimated scatterplot smooth. Broadly speaking, it calculates the mean value of the y variable locally for each region of the x scale.

This default option is more complex than we will usually need. To change the behaviors of plotting functions, we must give them some input specifying what aspect of their behavior we want to change and what we want to change it to. For example, we can change the method for geom_smooth() to lm, which stands for linear model. This will show a straight line relationship between the two variables.

fig2 = fig1 + geom_smooth(method=lm)
print(fig2)

Most geom_ functions have lots and lots of options that we can change in order to fine-tune our plot. For example, we can turn off the margin of error region that geom_smooth() draws by default, by setting the se argument to FALSE.

fig2 = fig1 + geom_smooth(method=lm, se=FALSE)
print(fig2)

(When writing a full data analysis, we will almost always assign plots into variables and then add to these plots to produce variations on the plot, as in the examples above. However, in most of the examples in the rest of this tutorial, I have repeated the commands for each new plot in full, so that it is easier to see all of the components of which each example plot consists.)

The order in which we add geoms to the plot matters. They will be drawn in the order that we added them. For example, if we create the plot above by first adding the smooth line and then the points, it will look slightly different. The difference in this case is fairly subtle, but if you look carefully you notice that some of the points are now drawn over the line.

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker)) + geom_smooth(method=lm) + geom_point()

When we create a plot with multiple components, we can make our R commands a little neater by putting each component of the plot on a new line after the initial plot definition. We can continue commands on a new line after the + symbol. This doesn’t change anything about the plot, but it makes our R commands easier for other people to read and understand.

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker)) +
  geom_smooth(method=lm) +
  geom_point()

Aesthetic mappings

As noted above, the aesthetic mappings of a plot determine which dimensions of the plot are used to represent which variables in the data frame. Any geom that is able to reflect an aesthetic mapping will do so.

ggplot(bw, aes(y=Birth_weight, x=Race)) +
  geom_boxplot()

levels(bw$Race)

## [1] "black" "other" "white"

bw$Race = factor(bw$Race, levels=c("black", "white", "other"))

ggplot(bw, aes(y=Birth_weight, x=Race)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker)) +
  geom_smooth(method=lm) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Race, color=Smoker)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Race, fill=Smoker)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Weight, fill=Smoker)) +
  geom_smooth(method=lm) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker, fill=Smoker)) +
  geom_smooth(method=lm) +
  geom_point()

ggplot(fat, aes(y=Waist, x=Weight, color=Fat)) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Age, size=Weight)) +
  geom_point()

ggplot(fat, aes(y=Waist, x=Weight, size=Fat)) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Weight, size=Race)) +
  geom_point()

## Warning: Using size for a discrete variable is not advised.

ggplot(marriage, aes(y=Marriage_age, x=Year, linetype=Sex)) +
  geom_line()

ggplot(bw, aes(y=Birth_weight, x=Weight, linetype=Smoker)) +
  geom_smooth(method=lm, se=FALSE) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Race, linetype=Smoker)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Weight, linetype=Visits)) +
  geom_smooth(method=lm, se=FALSE) +
  geom_point()

## Error: A continuous variable can not be mapped to linetype

ggplot(bw, aes(y=Birth_weight, x=Weight, linetype=factor(Visits))) +
  geom_smooth(method=lm, se=FALSE) +
  geom_point()

ggplot(marriage, aes(y=Marriage_age, x=Year, lty=Sex)) +
  geom_line()

ggplot(marriage, aes(y=Marriage_age, x=Year, linetype=Sex, shape=Sex)) +
  geom_line() +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Weight, shape=Race)) +
  geom_point()

ggplot(salience, aes(y=Error, x=RT, group=Subject)) +
  geom_point() +
  geom_smooth(se=FALSE)

## `geom_smooth()` using method = 'loess' and formula 'y ~ x'

Geometric objects

Different geometric objects are useful for showing different types of data and different features of those data. In addition, each geom is affected by some aesthetic mappings and not by others. So when choosing geoms for our plot we need to think carefully about which will show the important information clearly, and which may obscure it or mislead us.

The ? help for each geom_ function often gives some guidance on the appropriate use of the geom. It also gives a list of the aesthetics that the geom understands (under the heading Aesthetics). These help pages are linked in the sections below.

ggplot(salience, aes(y=Error, x=RT)) +
  geom_point()

ggplot(salience, aes(y=Error, x=RT)) +
  geom_point(shape="circle filled", fill="grey")

ggplot(fat, aes(y=Waist, x=Weight, size=Fat)) +
  geom_point(shape="circle filled", fill="grey")

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_point()

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_point(position=position_jitter(width=0.1, height=0))

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_jitter(width=0.1, height=0)

ggplot(bw, aes(y=Birth_weight, x=Age)) +
  geom_line()

levels(deaths$Age)

## [1] "0 to 1"   "1 to 4"   "5 to 14"  "15 to 24"

accidents_1950 = subset(deaths, Cause=="accidents" & Year==1950)

ggplot(accidents_1950, aes(y=Deaths, x=Age)) +
  geom_line()

## geom_path: Each group consists of only one observation. Do you need to
## adjust the group aesthetic?

ggplot(accidents_1950, aes(y=Deaths, x=Age, group=1)) +
  geom_line()

accidents = subset(deaths, Cause=="accidents")

ggplot(accidents, aes(y=Deaths, x=Age, linetype=factor(Year), group=Year)) +
  geom_line()

deaths_young_2005 = subset(deaths, Age=="0 to 1" & Year==2005)

ggplot(deaths_young_2005, aes(y=Deaths, x=Cause, group=1)) +
  geom_line()

ggplot(deaths_young_2005, aes(y=Deaths, x=Cause)) +
  geom_col()

ggplot(tt, aes(x=Class)) +
  geom_bar()

ggplot(tt, aes(y=..count.., x=Class)) +
  geom_bar()

ggplot(tt, aes(y=..prop.., x=Class)) +
  geom_bar()

ggplot(tt, aes(y=..prop.., x=Class, group=1)) +
  geom_bar()

ggplot(deaths_young_2005, aes(y=Deaths, x=Cause)) +
  geom_bar()

## Error: stat_count() must not be used with a y aesthetic.

ggplot(tt, aes(x=Class, fill=Status)) +
  geom_bar()

ggplot(tt, aes(x=Class, fill=Status)) +
  geom_bar(position=position_dodge())

ggplot(tt, aes(x=Class, color=Status)) +
  geom_bar(position=position_dodge())

ggplot(marriage, aes(y=Marriage_age, x=Year, fill=Sex)) +
  geom_col(position=position_dodge())

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_jitter(width=0.2, height=0)

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_boxplot() +
  geom_jitter(width=0.1, height=0)

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_boxplot(outlier.shape="") +
  geom_jitter(width=0.1, height=0)

ggplot(bw, aes(y=Birth_weight, x=Smoker)) +
  geom_jitter(width=0.1, height=0) +
  geom_boxplot(outlier.shape="")

ggplot(bw, aes(y=Birth_weight, x=Race, fill=Smoker)) +
  geom_boxplot()

ggplot(bw, aes(y=Birth_weight, x=Race, fill=Smoker)) +
  geom_boxplot(outlier.shape="") +
  geom_jitter(width=0.1, height=0)

ggplot(bw, aes(y=Birth_weight, x=Race, fill=Smoker)) +
  geom_boxplot(outlier.shape="") +
  geom_point(position=position_jitterdodge())

ggplot(bw, aes(y=Birth_weight, x=Race, fill=Smoker)) +
  geom_boxplot(outlier.shape="") +
  geom_point(position=position_jitterdodge(), shape="circle filled")

ggplot(wine, aes(y=Fruity, x=Citrus, label=Name)) +
  geom_point() +
  geom_text()

ggplot(wine, aes(y=Fruity, x=Citrus, label=Name)) +
  geom_point() +
  geom_text(hjust="left", vjust="bottom")

ggplot(wine, aes(y=Fruity, x=Citrus, label=Name)) +
  geom_point() +
  geom_text(hjust="inward")

ggplot(salience, aes(y=Error, x=RT)) +
  geom_point(shape="circle filled", fill="grey") +
  geom_hline(yintercept=0, lty="dashed", color="red")

ggplot(bw, aes(y=Birth_weight, x=Weight)) +
  geom_point() +
  geom_hline(yintercept=c(2.5,4.5), lty="dashed", color="red")

Custom layers

In the examples above we defined the data and the aesthetic mappings for the whole plot, and then each geom that we layered onto the plot displayed these data and mappings. Most of the time, this is what we want; the whole plot should conform to the same overall organization. However, occasionally we will want to apply a particular aesthetic mapping, or even different data, to just one of the geoms on the plot. For example, we may want one geom to map a particular variable to the color dimension, but it may be clearer for a different geom to map the same variable to the fill dimension instead. Or we may want one geom to display only a subset of the data.

This is easy to achieve with ggplot. The data and aesthetic mappings can also be defined separately for a geom when we add that geom to the plot. We simply supply the data and/or mappings as input to the geom_ function. Whereas the overall plot definition with the ggplot() function takes the data as its first input and the aesthetic mappings as the second, this is the other way around for the geom_ functions. Although this can be confusing, it has a certain logic, since the data are the most important and fundamental thing for the plot as a whole (and aesthetic mappings can be added to it later), but the mappings are the most important and most frequently changed thing for geoms. So if we want a geom to have an additional aesthetic mapping, we must give the aes() function as the first input to the geom_ function.

One use of a custom mapping like this is to ensure that a variable is reflected in the fill color for filled points, but in the line color for lines.

ggplot(bw, aes(y=Birth_weight, x=Weight)) +
  geom_point(aes(fill=Smoker), shape="circle filled") +
  geom_smooth(aes(color=Smoker), method=lm)

An alternative way of achieving the same thing is to define all the aesthetics for the main plot, but then ‘switch off’ some of them for specific geoms. We can switch an aesthetic mapping off by assigning the value NULL.

ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker, fill=Smoker)) +
  geom_point(aes(color=NULL), shape="circle filled") +
  geom_smooth(aes(fill=NULL), method=lm)

Notice that the mappings defined in the main plot function ggplot() still apply to the geoms that have their own mappings. Geoms inherit the mappings from the main plot, and then add or change any new mappings that we define just for them. (If we ever want to stop a geom from inheriting the aesthetic mappings from the main plot, we can set the argument inherit.aes=FALSE in the geom_ function, but this is not necessary very often).

Geoms may also display different data than those used for the main plot definition. One use of this is to use a geom to highlight only a small subset of the data. The text geom is frequently used with a subset of data, because applying it to the entire data frame usually results in a very cluttered plot.

For example, we can add the name of the least fruity wine to the plot of wines.

ggplot(wine, aes(y=Fruity, x=Citrus)) +
  geom_point() +
  geom_text(aes(label=Name), subset(wine, Fruity<3 & Citrus<2), hjust="inward")

Because the data are the second argument to geom_, we must assign the data argument by name (i.e. as data=) if we are not also supplying an aesthetic mapping to the geom_ function.

ggplot(wine, aes(y=Fruity, x=Citrus, label=Name)) +
  geom_point() +
  geom_text(data=subset(wine, Fruity<3 & Citrus<2), hjust="inward")

Labels

In the plots above, we relied on ggplot to fill in labels for the dimensions of the plot. It took these labels from the names of the variables that we mapped to the plot dimensions. Where feasible, we can just name the variables appropriately in the original data frame, and then their plot labels will be as we want them. But fairly often we will want to modify the labels on the plot. If we want labels with spaces in them, or if we want to state the units of the variable, it is very unwieldy to incorporate this into the name of the variable in the data frame. An alternative is to specify labels manually using the labs() function.

As with aes(), the arguments to the labs() function are assignments to plot dimensions. Because the labels are just literal text, and do not refer to a function or object in R, they must be given in quotation marks.

fig1 = ggplot(bw, aes(y=Birth_weight, x=Weight, color=Smoker)) +
  geom_point() +
  labs(y="Birth weight (kg)", x="Mother's weight (kg)")

print(fig1)

We can also use labs() to assign a caption. We don’t always need this, but one good use of the caption is to provide a brief reference for where the data come from. This can be important for plots that might be shown without their original context, because it ensures that a record of the source is built in to the plot image.

fig1 = fig1 +
  labs(caption="Data: Baystate Medical Center, 1986")

print(fig1)

labs() can also assign a title at the top of the plot. Again, we won’t always need this, but one use of a title is to assign a distinguishing label to a plot that we will later use as one of several plots presented at once.

fig1 = fig1 +
  labs(title="Study A")

print(fig1)

Since writing out labels can be tedious, and we don’t want to have to repeat it for multiple plots of the same data, the labels should be one of the first things we add to a basic plot definition. We can then add different geoms and mappings to this basic plot, and the labels will be reflected in each new version we create.

fig0 = ggplot(bw, aes(y=Birth_weight)) +
  labs(y="Birth weight (kg)", caption="Data: Baystate Medical Center, 1986")

fig1 = fig0 +
  aes(x=Weight) +
  geom_point()

fig2 = fig0 +
  aes(x=Smoker) +
  geom_boxplot()

# ... and so on.

Statistical summaries

So far, we have mostly been creating plots that display all of the observations in our data frame. This is usually what we want to do, at least for an initial plot. Otherwise we might miss important features of our data, such as single extreme observations that warrant extra attention. But we have already encountered a few ggplot functions that calculate and display some summary statistics from the data rather than the data themselves.

• geom_smooth() summarizes a smooth relationship between x and y variables
• geom_bar() counts up how many observations there are in a group, or the proportion of observations in a group
• geom_boxplot() shows a summary of the spread of the observations, using the median and the IQR, as we learned above

There is a more general ggplot function for first summarizing the data in a few statistics, and then displaying those statistics instead of (or as well as) the data themselves. The stat function stat_summary() does this.

Let’s see what it does by default for a simple side-by-side comparison of a two-level factor variable.

fig_smoking = fig0 +
  aes(x=Smoker) +
  stat_summary()

print(fig_smoking)

## No summary function supplied, defaulting to `mean_se()

As we have seen before, a function that has a specific default behavior that we might want to change will warn us what default options it is using (for example, we saw this for the smoothing method of geom_smooth() earlier). stat_summary() requires a ‘summary function’: an R function that will take the data as its input and will output one or more summary statistics to be plotted. We are told here that the default summary function for stat_summary() is mean_se(). This function calculates the mean value of the y variable, along with its Standard Error (SE). We will learn more about Standard Errors in a later tutorial, but for now consider the Standard Error as giving a sort of ‘margin of error’ for estimating the true value of some statistic in the general population from which our observations were drawn.

Let’s look at the output of mean_se() when applied to the birth weights of the babies born to non-smoking mothers.

mean_se(bw$Birth_weight[bw$Smoker=="no"])

The output comes in the form of a data frame with three columns:

• y: the mean value of the y variable, in this case birth weight
• ymin: the mean value of the y variable, minus the SE
• ymax: the mean value of the y variable, plus the SE

Together, ymin and ymax provide a margin of error for estimating the mean value of the y variable in the general population from the values in our data. This can be a useful way of summarizing our data if the goal of our project is to conclude something about the population. It is these values that stat_summary() displays. We can see this if we compare the values we just got from mean_se() to the left half of the plot above.

stat_summary() takes a summary function and applies it separately to each grouping that we defined for the plot. Because we mapped the smoking factor variable to the x dimension, we see the mean ± the Standard Error displayed for each level of this factor separately.

We can supply a summary function to the fun.data argument for stat_summary(). If we supply the mean_se() function, we get the same plot as by default.

fig_smoking = fig0 +
  aes(x=Smoker) +
  stat_summary(fun.data=mean_se)

There are alternative summary functions. For example, mean_sdl() calculates the mean value of the y variable ± 2 Standard Deviations (SDs). Unlike the Standard Error, the Standard Deviation is not concerned with estimating anything in the population in general, and is just a description of how spread out our observed data are along the y scale. Again, this is something that we will learn about in more detail later.

mean_sdl(bw$Birth_weight[bw$Smoker=="no"])

fig_smoking = fig0 +
  aes(x=Smoker) +
  stat_summary(fun.data=mean_sdl)

print(fig_smoking)

For simpler summaries that summarize the data in a single number, we can use a summary function that calculates a single value. We have seen some such functions already in an earlier tutorial, such as mean() and median(). Because the fun.data argument expects a function that outputs a range with a ymin and a ymax, we must use a different argument for single-number summaries: fun.y. We must also tell stat_summary() which geom we want to use to display the summary, since the default is to use a point with lines (geom_pointrange). We can supply the name of the geom to the geom argument.

fig_smoking = fig0 +
  aes(x=Smoker) +
  stat_summary(fun.y=mean, geom="point")

print(fig_smoking)

But a plot with just a single summary statistic on it is very low in information. More often we will want to use stat_summary() as an addition to displaying the individual observations. For example the individual observations as points and then a summary pointrange on top.

fig_smoking = fig0 +
  aes(x=Smoker) +
  geom_jitter(width=0.1, height=0) +
  stat_summary(fun.data=mean_sdl, color="red")

print(fig_smoking)

To make sure our plot can be interpreted correctly, we should always mention in our written description of the plot what statistics the points and ranges of the summary show.

Scales

In all our example plots so far, ggplot has decided for us which values to label along the axes of the plot. And it tends to make fairly good decisions about this. But sometimes we will want to take control of this aspect of our plot ourselves. For example, if we are showing values on a rating scale that uses particular numbers, such as ratings from 0 to 10, we might want to show only these numbers along the plot axis.

ggplot’s scale_ functions customize the appearance of scales. There are lots of such functions, and it can sometimes take a bit of work to find out which one we want. But generally the function will have the name of the plot dimension whose scale we wish to alter, plus some indication of what kind of scale we want to apply. For example, if we want to change the values shown for the birth weights, we need the function scale_y_continuous(), because we are dealing with the y dimension and because birth weight is a numeric variable with a continous scale.

The breaks argument tells the scale_ function at what points on the scale we would like to label the values. The input is a vector of values. The breaks are reflected in the numbering along the axis and in the placing of gridlines in the plot background.

wine_ratings = ggplot(wine, aes(y=Overall_preference, x=Label)) +
  geom_jitter(width=0.1, height=0)

wine_ratings +
  scale_y_continuous(breaks=0:10)

The limits argument sets the lower and upper end of the scale. The input for this is a vector of two values (minimum then maximum).

wine_ratings +
  scale_y_continuous(breaks=0:10, limits=c(0,10))

And the labels argument allows us to specify something other than numbers for the labelling of the values. The input is a vector of the same length as the breaks argument.

wine_ratings +
  scale_y_continuous(breaks=c(0,5,10), labels=c("bad","medium","good"), limits=c(0,10))

To change the colors assigned to factor levels by the color and fill aesthetics, we can use scale_color_manual(). The required input is again a vector, but this time a vector of color names, one for each level of the factor, in an order corresponding to the order of the factor levels. Since these are not ‘break points’ along a scale, the argument is called values rather than breaks. In addition, we can determine which aesthetic mappings the scale applies to, using the aesthetics argument. If we input the name of a single aesthetic, for example "fill", the scale will be applied to that aesthetic, but we can also input a vector of names of aesthetics to apply the same scale to both the color and fill dimensions.

levels(bw$Smoker)

## [1] "no"  "yes"

fig_smoking = fig0 +
  aes(x=Weight) +
  scale_color_manual(values=c("skyblue","brown"), aesthetics="fill") +
  geom_point(aes(fill=Smoker), shape="circle filled")

print(fig_smoking)

And to change the continuous color gradient for a numeric variable, we can use scale_color_gradient(). The low and high arguments specify the color at each end of the scale, and a smooth gradient of color is filled in betwen them to represent the values along the scale.

fig_fat = ggplot(fat, aes(y=Waist, x=Weight, fill=Fat)) +
  labs(y="Waist circumference (cm)", x="Weight (kg)", fill="Proportion\nbody fat") +
  scale_color_gradient(low="yellow", high="red", aesthetics="fill") +
  geom_point(shape="circle filled",size=3)

print(fig_fat)

(If you are wondering what named colors are available in R, you can see a full list of them by typing colors() into the console.)

There are also several packages for R that provide special color scales. For example, the viridis package provides a color scale that is more easily readable by people with the most common forms of color blindness.

library(viridis)

fig_fat + scale_color_viridis(aesthetics="fill")

## Scale for 'fill' is already present. Adding another scale for 'fill',
## which will replace the existing scale.

Facets

If we want to compare levels of a factor variable, such as smokers and non-smokers, different varieties of wine, and so on, we can map these variables to the x or color dimensions, as we did in many of the examples above. But sometimes the simplest way to compare subsets of the data is in two or more separate plots, shown side by side. Indeed, if we have already used the x and color dimensions for something else in our plot, then splitting the plot into separate panels may be our only choice if we want to show one more variable.

Separate panels showing subsets of the data are called ‘facets’. ggplot’s facet_ functions apply facets to a plot. To split a plot into separate panels, we just add a facet_ function to the plot, specifying which variable to split the data by. facet_wrap() handles the simplest case of splitting the data by just one variable. The input to facet_wrap() is a formula for splitting the data. We have not yet learned about formulas in R, and we will do so in more detail in a later tutorial. For now, just remember that a formula contains a ~ symbol, and that the variable (or variables) that accompany the ~ are used to split the data.

So to split our plot of birth weights into three panels, one for each ethnic group:

fig_smoking + facet_wrap(~Race)

One common use of facets is to check the behavior of each subject separately when we have collected data from multiple subjects. If a faceted plot has many separate panels, facet_wrap() organizes them into a grid.

fig_salience = ggplot(salience, aes(y=Error, x=RT, fill=SOA)) +
  labs(x="Reaction Time (ms)") +
  geom_point(shape="circle filled") +
  geom_hline(yintercept=0, lty="dashed", color="red")

fig_salience + facet_wrap(~Subject)

By default, each facet has the same scale for the x and y axes This is usually what we want, because we would like to be able to identify subjects who are in very different places along the scale. However, if we do not care so much about comparing the subjects all across the same scale, then we can allow each one to have their own scale, using the scales argument. Setting scales="free" will allow both x and y scales to differ for each facet, and setting scales="free_x" or scales="free_y" will allow only one of the scales to differ.

fig_salience + facet_wrap(~Subject, scales="free")

If we wish to show facets for the combination of levels from two factor variables, we can arrange the facets in a grid such that each row represents a level of one variable and each column represents a level of the other variable.

facet_grid() does this. The variable before the ~ in the formula is assigned to the rows, and the variable after the ~ to the columns.

fig_salience + facet_grid(Luminance~Orientation)

In the example above, the titles for each facet are not very helpful. This is because the levels of the Luminance and Orientation variables are just ‘absent’ and ‘present’. If we would like to see not only the names of the levels but also the names of the variables in the facet titles, we can set the argument labeller="label_both".

fig_salience + facet_grid(Luminance~Orientation, labeller="label_both")

Updating

If our data frame has changed, for example if we have recalculated the values of a variable, or have discarded some observations, then we will want to create a new plot for our modified data frame. Rather than write out all the plot commands again, we can update the existing plot by ‘adding’ the new data frame.

The symbol for adding a new data frame to a plot is slightly different from that for adding other plot features: %+%. (Commands enclosed in % % represent special, non-standard uses of a symbol or word. We won’t need to use these very often, so you can just remember that %+% means ‘change the data for a plot’.)

For example, if we discard some of the observations from the salience data set by subsetting the data frame, we can then add the subsetted data frame to the existing plot to see the result of the change.

salience_fast = subset(salience, RT<400)

fig_salience %+% salience_fast

It is important to remember that the new data frame replaces the original one, and is not drawn onto the plot additionally, as the + in %+% seems to suggest.

Themes

Perhaps we want to publish our plots in a journal or book that has specific style guidelines. For this, we will need to change more specific aspects of the plot’s appearance, such as the presence of gridlines, the placement of the legend, and so on. The theme() function makes changes to the appearance of a plot. This function has a great many different arguments, each of which controls one minor stylistic detail. They are too many to go into here, but you can look them up in the documentation to the theme() function should you ever need them.

A few ‘prepackaged’ theme functions are provided, which make multiple changes to a plot according to a particular style. For example, the ‘classic’ theme does not have guiding gridlines or a shaded background.

fig_smoking + theme_classic()

Saving plots

Of course we also want to save our plots as images so we can put them in articles, websites, presentations, and posters. One way of saving a plot is via the Export button in RStudio’s Plots tab. This is good for saving a ‘one-off’ plot that we aren’t likely to want to come back to and modify. But if we want to make the creation of the image reproducible, then we should include it as a command in our R script or markdown file. This allows us to come back and just run our entire analysis again, maybe with new data, and get the new plot image automatically.

The ggsave() function saves a plot to an image file. The first input is the name we want to give the file, and the second input is the plot object. We use the suffix of the filename to specify what image format we want.

ggsave("example_figure.png", fig_smoking)

## Saving 7 x 5 in image

ggsave("example_figure.png", fig_smoking, width=5, height=3)

ggsave("example_figure.svg", fig_smoking, width=5, height=3)